package testes;

import logica.locacao.Cobertura;
import logica.locacao.Plano;
import logica.locacao.Seguro;
import logica.util.Constantes;
import logica.veiculo.Acessorio;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class TestaPlano {

	private Plano plano1;
	private Plano plano2;
	private Seguro semSeguro = null;
	private double potencia = 1.9;
	
	@Before
	public void setUp(){
		String[] marcas1 = {"MarcaA","MarcaB","MarcaC","MarcaD"};
		String[] modelos1 = {"MarcaC","ModeloC1","ModeloC2","MarcaA","ModeloA1","MarcaB","ModeloB1","ModeloB2","ModeloB3","MarcaD","ModeloD1","ModeloD2","ModeloD3","ModeloD4"};
		Acessorio[] acessorios1 = {Acessorio.AB, Acessorio.VE, Acessorio.P2};
		
		try{
			plano1 = new Plano("00001",marcas1,modelos1,acessorios1,potencia);
		}
		catch(Exception e){
			System.out.println("(#1) "+e.getMessage());
		}
	}
	
	@SuppressWarnings("deprecation")
	@Test
	public void testaConstrutorESeusParametros(){
		
		/*
		 * TESTES QUE NAO DEVEM LANCAR EXCECOES
		 */

		Assert.assertEquals("(#2) Codigo incorreto!", plano1.getCodigo(), "00001");

		String[] esperada1 = {"MarcaA","MarcaB","MarcaC","MarcaD"};
		Assert.assertEquals("(#3) Array de Marcas incoreto!" , plano1.getMarcas(), esperada1);

		String[] esperada2 = {"ModeloA1","ModeloB1","ModeloB2","ModeloB3","ModeloC1","ModeloC2","ModeloD1","ModeloD2","ModeloD3","ModeloD4"};
		Assert.assertEquals("(#4) Array de Modelos incorreto!", plano1.getModelos(), esperada2);

		Acessorio[] esperada3 = {Acessorio.AB, Acessorio.VE, Acessorio.P2, null, null, null, null, null, null, null};
		Assert.assertEquals("(#5) Array de Acessorios incorreto!", plano1.getAcessorios(), esperada3);
		
		try{
			plano1.getSeguro();
		}
		catch ( Exception e ){
			Assert.assertEquals("(#6) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Nao contem seguro!");
		}

		Assert.assertEquals("(#6,5) Potencia invalida!", plano1.getPotencia(), 1.9, 0.1);
		
		Assert.assertEquals("(#7) 1a pos. do 1o array incorreto!", plano1.getMarcaXModelos().get(0)[0], "MarcaA");
		Assert.assertEquals("(#8) 1a pos. do 2o array incorreto!", plano1.getMarcaXModelos().get(1)[0], "MarcaB");
		Assert.assertEquals("(#9) 1a pos. do 3o array incorreto!", plano1.getMarcaXModelos().get(2)[0], "MarcaC");
		Assert.assertEquals("(#10) 1a pos. do 4o array incorreto!", plano1.getMarcaXModelos().get(3)[0], "MarcaD");
		Assert.assertEquals("(#11) 2a pos. do 1o array incorreto!", plano1.getMarcaXModelos().get(0)[1], "ModeloA1");
		Assert.assertEquals("(#12) 2a pos. do 2o array incorreto!", plano1.getMarcaXModelos().get(1)[1], "ModeloB1");
		Assert.assertEquals("(#13) 3a pos. do 2o array incorreto!", plano1.getMarcaXModelos().get(1)[2], "ModeloB2");
		Assert.assertEquals("(#14) 4a pos. do 2o array incorreto!", plano1.getMarcaXModelos().get(1)[3], "ModeloB3");
		Assert.assertEquals("(#15) 2a pos. do 3o array incorreto!", plano1.getMarcaXModelos().get(2)[1], "ModeloC1");
		Assert.assertEquals("(#16) 3a pos. do 3o array incorreto!", plano1.getMarcaXModelos().get(2)[2], "ModeloC2");
		Assert.assertEquals("(#17) 2a pos. do 4o array incorreto!", plano1.getMarcaXModelos().get(3)[1], "ModeloD1");
		Assert.assertEquals("(#18) 3a pos. do 4o array incorreto!", plano1.getMarcaXModelos().get(3)[2], "ModeloD2");
		Assert.assertEquals("(#19) 4a pos. do 4o array incorreto!", plano1.getMarcaXModelos().get(3)[3], "ModeloD3");
		Assert.assertEquals("(#20) 5a pos. do 4o array incorreto!", plano1.getMarcaXModelos().get(3)[4], "ModeloD4");

		/*
		 * TESTES QUE DEVEM LANCAR EXCECOES
		 */
		
		String[] marcas2A = {"MarcaE","MarcaF","MarcaE"};
		String[] modelos2A = {"MarcaE","ModeloE1","ModeloE2","MarcaF","ModeloF1"};
		Acessorio[] acessorios2A = {Acessorio.AC, Acessorio.VE, Acessorio.P4};

		try{
			plano2 = new Plano("00002",marcas2A,modelos2A,acessorios2A,potencia);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#21) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Padrao incorreto! Ha marcas repetidas no array de marcas!");
		}
		
		String[] marcas2B = {"MarcaE","MarcaF"};
		String[] modelos2B = {"MarcaF","MarcaF1","MarcaE","ModeloE1","ModeloE2","MarcaF","ModeloF2"};
		Acessorio[] acessorios2B = {Acessorio.VE, Acessorio.P4};
		
		try{
			plano2 = new Plano("00003",marcas2B,modelos2B,acessorios2B,semSeguro,potencia);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#22) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Padrao incorreto! Cada marca deve ter estritamente 1 imagem no array de modelos!");
		}
		
		String[] marcas2C = {"MarcaE","MarcaF"};
		String[] modelos2C = {"MarcaF1","MarcaE","ModeloE1","ModeloE2","MarcaF","ModeloF2"};
		Acessorio[] acessorios2C = {Acessorio.P4};
		
		try{
			plano2 = new Plano("00004",marcas2C,modelos2C,acessorios2C,potencia);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#23) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Padrao incorreto! Nao deve haver modelos antes da primeria marca no array de modelos!");
		}
		
		String[] marcas2D = {"MarcaE","MarcaF"};
		String[] modelos2D = {"MarcaE","ModeloE1","ModeloE2","MarcaF"};
		Acessorio[] acessorios2D = {Acessorio.P4};
		
		try{
			plano2 = new Plano("00005",marcas2D,modelos2D,acessorios2D,potencia);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#24) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Nao pode haver marcas sem pelo menos um modelo associado no array de modelos!");
		}
		
		String[] marcas2E = {"MarcaE"};
		String[] modelos2E = {"MarcaE","ModeloE1","ModeloE2","ModeloE3","ModeloE4","ModeloE5","ModeloE6","ModeloE7","ModeloE8","ModeloE9","ModeloE10"};
		Acessorio[] acessorios2E = {Acessorio.P4};
		
		try{
			plano2 = new Plano("00006",marcas2E,modelos2E,acessorios2E,potencia);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#25) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Quantidade de modelos para cada marca nao pode ser superior a "+(Constantes.QTDE_MODELOS_POR_MARCA-1)+", logo (ModeloE10) nao foi inserido!");
		}
		
		try{
			plano2 = new Plano("00006",marcas2E,modelos2E,acessorios2E,-1);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#25) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Potencia invalida!");
		}
		
		try{
			plano2 = new Plano("00006",marcas2E,modelos2E,acessorios2E,0);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#25) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Potencia invalida!");
		}
	}
	
	@Test
	public void testaSetsEGets(){
		
		// ESSES CATCH ABAIXO DEVERAO RODAR
		try{
			plano1.setCodigo("0002");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#26) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Codigo invalido!");
		}
		try{
			plano1.setCodigo("0000a");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#27) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Codigo invalido!");
		}
		try{
			plano1.setCodigo(null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#28) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Codigo invalido!");
		}
		try{
			plano1.setCodigo("");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#29) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Codigo invalido!");
		}
		
		// ESSE CATCH ABAIXO NAO DEVERA RODAR
		try{
			plano1.setCodigo("00006");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#30) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Codigo invalido!");
		}
		Assert.assertEquals("(#31) Codigo errado!", "00006", plano1.getCodigo());

		// ESSES CATCHS ABAIXO DEVERAO RODAR
		Acessorio[] acessorios1 = {Acessorio.DVD,Acessorio.TR4};
		try{
			plano1.setAcessorios(acessorios1);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#32) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Acessorios invalidos!");
		}
		try{
			plano1.setAcessorios(null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#33) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Acessorios invalidos!");
		}

		Acessorio[] acessorios2 = {Acessorio.DH,Acessorio.VE,Acessorio.GPS,null,null,null,null,null,null,null,null};
		try{
			plano1.setAcessorios(acessorios2);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#34) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Acessorios invalidos!");
		}
		
		// ESSE CATCH ABAIXO NAO DEVERA RODAR
		Acessorio[] acessorios3 = {Acessorio.DH,Acessorio.VE,Acessorio.GPS,null,null,null,null,null,null,null};
		try{
			plano1.setAcessorios(acessorios3);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#35) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Acessorios invalidos!");
		}
		
		// ESSES CATCH ABAIXO DEVERAO RODAR
		try{
			plano1.getSeguro();
		}
		catch ( Exception e ){
			Assert.assertEquals("(#36) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Nao contem seguro!");
		}
		try{
			plano1.setSeguro(null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#37) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Seguro invalido!");
		}
		
		Seguro seguro = null;
		//ESSE CATCH ABAIXO NAO DEVE RODAR
		try{
			seguro = new Seguro(Cobertura.PARCIAL, 50);
		}
		catch ( Exception e ){
			System.out.println("(#37,5) Seguro errado!");
		}
		
		try{
			plano1.setSeguro(seguro);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#38) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Nao acontecera!");
		}

		//ESSE CATCH ABAIXO NAO DEVERA RODAR
		try{
			Assert.assertEquals("(#39) Seguro incorreto!", plano1.getSeguro(), seguro);
		}
		catch (Exception e){
			System.out.println("(#40) Nao deveria vir para ca!");
		}
		
		String[] marcas3 = {"MarcaA","MarcaB","MarcaC"};
		String[] modelos3 = {"MarcaA","ModeloA1","MarcaB","ModeloB1","MarcaC","ModeloC1"};
		//ESSES CATCH ABAIXO DEVERAO RODAR
		try{
			plano1.setMarcaXModelos(marcas3, null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#41) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Marca(s) e/ou modelo(s) invalido(s)!");
		}
		try{
			plano1.setMarcaXModelos(null, modelos3);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#42) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Marca(s) e/ou modelo(s) invalido(s)!");
		}
		try{
			plano1.setMarcaXModelos(null, null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#43) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Marca(s) e/ou modelo(s) invalido(s)!");
		}
		//ESSE CATCH ABAIXO NAO DEVERA RODAR
		try{
			plano1.setMarcaXModelos(marcas3, modelos3);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#44) Mensagem de erro errada: "+e.getMessage(), e.getMessage(), "Marca(s) e/ou modelo(s) invalido(s)!");
		}
		String[] modelos3Result = {"ModeloA1","ModeloB1","ModeloC1"};
		Assert.assertEquals("Marcas incorretas!", plano1.getMarcas(), marcas3);
		Assert.assertEquals("Modelos incorretos!", plano1.getModelos(), modelos3Result);
		
		Assert.assertEquals("(#45) 1a pos. do 1o array incorreto!", plano1.getMarcaXModelos().get(0)[0], "MarcaA");
		Assert.assertEquals("(#46) 1a pos. do 2o array incorreto!", plano1.getMarcaXModelos().get(1)[0], "MarcaB");
		Assert.assertEquals("(#47) 1a pos. do 3o array incorreto!", plano1.getMarcaXModelos().get(2)[0], "MarcaC");
		Assert.assertEquals("(#48) 2a pos. do 1o array incorreto!", plano1.getMarcaXModelos().get(0)[1], "ModeloA1");
		Assert.assertEquals("(#49) 2a pos. do 2o array incorreto!", plano1.getMarcaXModelos().get(1)[1], "ModeloB1");
		Assert.assertEquals("(#50) 2a pos. do 3o array incorreto!", plano1.getMarcaXModelos().get(2)[1], "ModeloC1");
		
		plano1.setPotencia(10);
		Assert.assertEquals("Potencia errada!", plano1.getPotencia(), 10, 0.1 );

	}
	
	@Test
	public void testaAdicionarRemover(){
		
		try{
			plano1.adicionarAcessorio(null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#51) Mensagem de erro errada!", e.getMessage(), "Acessorio invalido!");
		}
		
		Acessorio[] acessorios4 = {Acessorio.AB, Acessorio.VE, Acessorio.P2};
		Acessorio[] acessorios4Result = {Acessorio.AB, Acessorio.VE, Acessorio.P2,null,null,null,null,null,null,null};
		try{
			plano1.adicionarAcessorio(Acessorio.P2);
		}
		catch ( Exception e ){
			System.out.println("(#52) Nao devia ter lancado essa excecao: "+e.getMessage());
		}
		Assert.assertEquals("(#53) Acessorios incorretos!", plano1.getAcessorios(), acessorios4Result);

		Acessorio[] acessorios5 = {Acessorio.AB, Acessorio.VE, Acessorio.P2, Acessorio.TR4};
		Acessorio[] acessorios5Result = {Acessorio.AB, Acessorio.VE, Acessorio.P2, Acessorio.TR4,null,null,null,null,null,null};
		try{
			plano1.adicionarAcessorio(Acessorio.TR4);
		}
		catch ( Exception e ){
			System.out.println("(#54) Nao devia ter lancado essa excecao: "+e.getMessage());
		}
		Assert.assertEquals("(#55) Acessorios incorretos!", plano1.getAcessorios(), acessorios5Result);

		//
		try{
			plano1.adicionarAcessorios(null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#56) Mensagem de erro errada!", e.getMessage(), "Acessorios invalidos!");
		}
		
		Acessorio[] acessorios6 = {Acessorio.AB, Acessorio.VE, Acessorio.P2};
		try{
			plano1.adicionarAcessorios(acessorios6);
		}
		catch ( Exception e ){
			System.out.println("(#57) Nao devia ter lancado essa excecao: "+e.getMessage());
		}
		Assert.assertEquals("(#58) Acessorios incorretos!", plano1.getAcessorios(), acessorios5Result);

		Acessorio[] acessorios7 = {Acessorio.AB, Acessorio.VE, Acessorio.P2, Acessorio.TR4};
		try{
			plano1.adicionarAcessorios(acessorios7);			
		}
		catch ( Exception e ){
			System.out.println("(#58,5) Nao devia ter lancado essa excecao: "+e.getMessage());
		}
		Assert.assertEquals("(#59) Acessorios incorretos!", plano1.getAcessorios(), acessorios5Result);
		
		Acessorio[] acessorios8 = {Acessorio.ABS, Acessorio.CDR, Acessorio.DVD, Acessorio.GPS, Acessorio.TE, Acessorio.AC};
		Acessorio[] acessorios9 = {Acessorio.AB, Acessorio.VE, Acessorio.P2, Acessorio.TR4, Acessorio.ABS, Acessorio.CDR, Acessorio.DVD, Acessorio.GPS, Acessorio.TE, Acessorio.AC};
		try{
			plano1.adicionarAcessorios(acessorios8);			
		}
		catch ( Exception e ){
			System.out.println("(#60) Nao devia ter lancado essa excecao: "+e.getMessage());
		}
		Assert.assertEquals("(#61) Acessorios incorretos!", plano1.getAcessorios(), acessorios9);
	
		try{
			plano1.adicionarAcessorio(Acessorio.P4);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#62) Mensagem de erro errada!", e.getMessage(), "Nao houve espaco para o novo acessorio Quatro Portas!");
		}
		Assert.assertEquals("(#63) Acessorios incorretos!", plano1.getAcessorios(), acessorios9);

		try{
			plano1.removerAcessorio(Acessorio.P4);
		}
		catch ( Exception e ){
			System.out.println("(#64) Nao deveria entrar aqui!");
		}
		Assert.assertEquals("(#65) Acessorios incorretos!", plano1.getAcessorios(), acessorios9);
		try{
			plano1.removerAcessorio(null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#66) Mensagem de erro errada!", e.getMessage(), "Acessorio invalido!");
		}
		Assert.assertEquals("(#67) Acessorios incorretos!", plano1.getAcessorios(), acessorios9);

		try{
			plano1.removerAcessorio(Acessorio.P2);
		}
		catch ( Exception e ){
			System.out.println("(#68) Nao deveria entrar aqui!");
		}
		Acessorio[] acessorios10 = {Acessorio.AB, Acessorio.VE, null, Acessorio.TR4, Acessorio.ABS, Acessorio.CDR, Acessorio.DVD, Acessorio.GPS, Acessorio.TE, Acessorio.AC};
		Assert.assertEquals("(#69) Acessorios incorretos!", plano1.getAcessorios(), acessorios10);

		try{
			plano1.removerAcessorio(Acessorio.DVD);
		}
		catch ( Exception e ){
			System.out.println("(#70) Nao deveria entrar aqui!");
		}
		Acessorio[] acessorios11 = {Acessorio.AB, Acessorio.VE, null, Acessorio.TR4, Acessorio.ABS, Acessorio.CDR, null, Acessorio.GPS, Acessorio.TE, Acessorio.AC};
		Assert.assertEquals("(#71) Acessorios incorretos!", plano1.getAcessorios(), acessorios11);

		
		
		String[] marcas3 = {"MarcaA","MarcaB","MarcaC"};
		String[] modelos3 = {"MarcaC","ModeloC1","MarcaA","ModeloA1","MarcaB","ModeloB1"};
		Acessorio[] acessorios3 = {Acessorio.AB, Acessorio.VE, Acessorio.P2};
		
		try{
			plano2 = new Plano("00007",marcas3,modelos3,acessorios3,potencia);
			plano2.adicionarMarcaEModelo("MarcaD", "ModeloD1");
		}
		catch ( Exception e ){
			System.out.println("(#72) Nao deveria entrar aqui!");
		}
		
		String[] marcas4 = {"MarcaA","MarcaB","MarcaC","MarcaD"};
		String[] modelos4Result = {"ModeloA1","ModeloB1","ModeloC1","ModeloD1"};
		Assert.assertEquals("(#72,3) Marcas incorretas!", plano2.getMarcas(), marcas4);		
		Assert.assertEquals("(#72,8) Modelos incorretos!", plano2.getModelos(), modelos4Result);
		
		Assert.assertEquals("(#73) 1a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[0], "MarcaA");
		Assert.assertEquals("(#74) 1a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[0], "MarcaB");
		Assert.assertEquals("(#75) 1a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[0], "MarcaC");
		Assert.assertEquals("(#76) 1a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[0], "MarcaD");
		Assert.assertEquals("(#77) 2a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[1], "ModeloA1");
		Assert.assertEquals("(#78) 2a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[1], "ModeloB1");
		Assert.assertEquals("(#79) 2a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[1], "ModeloC1");
		Assert.assertEquals("(#80) 2a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[1], "ModeloD1");

		String[] modelos5 = {"ModeloA1", "ModeloA2"};
		String[] modelos6 = {"ModeloD2", "ModeloD3"};
		String[] modelos7 = {"ModeloE1", "ModeloE2", "ModeloE3", "ModeloE4"};

		try{
			plano2.adicionarMarcaEModelos("MarcaA", modelos5);
			plano2.adicionarMarcaEModelos("MarcaD", modelos6);
			plano2.adicionarMarcaEModelos("MarcaE", modelos7);
		}
		catch ( Exception e ){
			System.out.println("(#81) Nao era pra entrar aqui, mas a excecao pega foi: "+e.getMessage());
		}
		
		String[] marcas8 = {"MarcaA", "MarcaB", "MarcaC", "MarcaD", "MarcaE"};
		String[] modelos8Result = {"ModeloA1","ModeloA2","ModeloB1","ModeloC1","ModeloD1","ModeloD2","ModeloD3","ModeloE1","ModeloE2","ModeloE3","ModeloE4"};
		Assert.assertEquals("(#81,3) Marcas incorretas!", plano2.getMarcas(), marcas8);
		Assert.assertEquals("(#81,8) Modelos incorretos!", plano2.getModelos(), modelos8Result);
		
		Assert.assertEquals("(#82) 1a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[0], "MarcaA");
		Assert.assertEquals("(#83) 1a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[0], "MarcaB");
		Assert.assertEquals("(#84) 1a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[0], "MarcaC");
		Assert.assertEquals("(#85) 1a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[0], "MarcaD");
		Assert.assertEquals("(#86) 1a pos. do 5o array incorreto!", plano2.getMarcaXModelos().get(4)[0], "MarcaE");
		Assert.assertEquals("(#87) 2a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[1], "ModeloA1");
		Assert.assertEquals("(#88) 3a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[2], "ModeloA2");
		Assert.assertEquals("(#89) 2a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[1], "ModeloB1");
		Assert.assertEquals("(#90) 2a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[1], "ModeloC1");
		Assert.assertEquals("(#91) 2a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[1], "ModeloD1");
		Assert.assertEquals("(#92) 3a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[2], "ModeloD2");
		Assert.assertEquals("(#93) 4a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[3], "ModeloD3");
		Assert.assertEquals("(#94) 2a pos. do 5o array incorreto!", plano2.getMarcaXModelos().get(4)[1], "ModeloE1");
		Assert.assertEquals("(#95) 3a pos. do 5o array incorreto!", plano2.getMarcaXModelos().get(4)[2], "ModeloE2");
		Assert.assertEquals("(#96) 4a pos. do 5o array incorreto!", plano2.getMarcaXModelos().get(4)[3], "ModeloE3");
		Assert.assertEquals("(#97) 5a pos. do 5o array incorreto!", plano2.getMarcaXModelos().get(4)[4], "ModeloE4");
		
		try{
			plano2.adicionarMarcaEModelo(null,null);
		}
		catch (Exception e){
			Assert.assertEquals("(#98) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelo invalido(s)!");
		}
		try{
			plano2.adicionarMarcaEModelo("MarcaF",null);
		}
		catch (Exception e){
			Assert.assertEquals("(#99) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelo invalido(s)!");
		}
		try{
			plano2.adicionarMarcaEModelo(null,"MarcaF1");
		}
		catch (Exception e){
			Assert.assertEquals("(#100) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelo invalido(s)!");
		}
		String[] modelos9 = {"ModeloF1","ModeloF2"};
		try{
			plano2.adicionarMarcaEModelos(null,null);
		}
		catch (Exception e){
			Assert.assertEquals("(#101) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelos invalidos!");
		}
		try{
			plano2.adicionarMarcaEModelos("MarcaF",null);
		}
		catch (Exception e){
			Assert.assertEquals("(#102) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelos invalidos!");
		}
		try{
			plano2.adicionarMarcaEModelos(null,modelos9);
		}
		catch (Exception e){
			Assert.assertEquals("(#103) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelos invalidos!");
		}

		try{
			plano2.removerModeloDaMarca("MarcaF", "ModeloF1");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#104) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelo solicitado(s) para remocao nao existe(m)!");
		}
		try{
			plano2.removerModeloDaMarca("MarcaB", "ModeloB2");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#105) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelo solicitado(s) para remocao nao existe(m)!");
		}
		try{
			plano2.removerModeloDaMarca(null, null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#106) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelos invalidos!");
		}
		try{
			plano2.removerModeloDaMarca("MarcaA", null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#107) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelos invalidos!");
		}
		try{
			plano2.removerModeloDaMarca(null, "ModeloA1");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#108) Mensagem de erro errada!", e.getMessage(), "Marca e/ou modelos invalidos!");
		}
		
		try{
			plano2.removerModeloDaMarca("MarcaB", "ModeloB1");
		}
		catch ( Exception e ){
			System.out.println("(#109) Nao deveria ter entrado aqui!");
		}
		
		String[] marcas10 = {"MarcaA", "MarcaC", "MarcaD","MarcaE"};
		String[] modelos10Result = {"ModeloA1","ModeloA2","ModeloC1","ModeloD1","ModeloD2","ModeloD3","ModeloE1","ModeloE2","ModeloE3","ModeloE4"};
		
		Assert.assertEquals("(#110) Marcas incorretas!", plano2.getMarcas(), marcas10);
		Assert.assertEquals("(#111) Modelos incorretos!", plano2.getModelos(), modelos10Result);
		
		Assert.assertEquals("(#112) 1a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[0], "MarcaA");
		Assert.assertEquals("(#113) 1a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[0], "MarcaC");
		Assert.assertEquals("(#115) 1a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[0], "MarcaD");
		Assert.assertEquals("(#116) 1a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[0], "MarcaE");
		Assert.assertEquals("(#117) 2a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[1], "ModeloA1");
		Assert.assertEquals("(#118) 3a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[2], "ModeloA2");
		Assert.assertEquals("(#119) 2a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[1], "ModeloC1");
		Assert.assertEquals("(#120) 2a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[1], "ModeloD1");
		Assert.assertEquals("(#121) 3a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[2], "ModeloD2");
		Assert.assertEquals("(#122) 4a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[3], "ModeloD3");
		Assert.assertEquals("(#123) 2a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[1], "ModeloE1");
		Assert.assertEquals("(#124) 3a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[2], "ModeloE2");
		Assert.assertEquals("(#125) 4a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[3], "ModeloE3");
		Assert.assertEquals("(#126) 5a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[4], "ModeloE4");

		try{
			plano2.removerModeloDaMarca("MarcaE", "ModeloE3");
		}
		catch ( Exception e ){
			System.out.println("(#127) Nao deveria ter entrado aqui!");
		}
		
		String[] marcas11 = {"MarcaA", "MarcaC", "MarcaD","MarcaE"};
		String[] modelos11Result = {"ModeloA1","ModeloA2","ModeloC1","ModeloD1","ModeloD2","ModeloD3","ModeloE1","ModeloE2","ModeloE4"};
		
		Assert.assertEquals("(#128) Marcas incorretas!", plano2.getMarcas(), marcas11);
		Assert.assertEquals("(#129) Modelos incorretos!", plano2.getModelos(), modelos11Result);
		
		Assert.assertEquals("(#130) 1a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[0], "MarcaA");
		Assert.assertEquals("(#131) 1a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[0], "MarcaC");
		Assert.assertEquals("(#132) 1a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[0], "MarcaD");
		Assert.assertEquals("(#133) 1a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[0], "MarcaE");
		Assert.assertEquals("(#134) 2a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[1], "ModeloA1");
		Assert.assertEquals("(#135) 3a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[2], "ModeloA2");
		Assert.assertEquals("(#136) 2a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[1], "ModeloC1");
		Assert.assertEquals("(#137) 2a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[1], "ModeloD1");
		Assert.assertEquals("(#138) 3a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[2], "ModeloD2");
		Assert.assertEquals("(#139) 4a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[3], "ModeloD3");
		Assert.assertEquals("(#140) 2a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[1], "ModeloE1");
		Assert.assertEquals("(#141) 3a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[2], "ModeloE2");
		Assert.assertEquals("(#142) 5a pos. do 4o array incorreto!", plano2.getMarcaXModelos().get(3)[4], "ModeloE4");

		try{
			plano2.removerMarca(null);
		}
		catch ( Exception e ){
			Assert.assertEquals("(#143) Mensagem de erro errada!", e.getMessage(), "Marca invalida!");
		}
		try{
			plano2.removerMarca("MarcaB");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#144) Mensagem de erro errada!", e.getMessage(), "A marca solicitada para remocao nao existe!");
		}
		try{
			plano2.removerMarca("MarcaD");
		}
		catch ( Exception e ){
			System.out.println("(#145) Nao deveria ter entrado aqui!");
		}
		
		String[] marcas12 = {"MarcaA", "MarcaC","MarcaE"};
		String[] modelos12Result = {"ModeloA1","ModeloA2","ModeloC1","ModeloE1","ModeloE2","ModeloE4"};
		
		Assert.assertEquals("(#146) Marcas incorretas!", plano2.getMarcas(), marcas12);
		Assert.assertEquals("(#147) Modelos incorretos!", plano2.getModelos(), modelos12Result);
		
		Assert.assertEquals("(#148) 1a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[0], "MarcaA");
		Assert.assertEquals("(#149) 1a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[0], "MarcaC");
		Assert.assertEquals("(#150) 1a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[0], "MarcaE");
		Assert.assertEquals("(#151) 2a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[1], "ModeloA1");
		Assert.assertEquals("(#152) 3a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[2], "ModeloA2");
		Assert.assertEquals("(#153) 2a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[1], "ModeloC1");
		Assert.assertEquals("(#154) 2a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[1], "ModeloE1");
		Assert.assertEquals("(#155) 3a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[2], "ModeloE2");
		Assert.assertEquals("(#156) 5a pos. do 3o array incorreto!", plano2.getMarcaXModelos().get(2)[4], "ModeloE4");

		try{
			plano2.removerModeloDaMarca("MarcaC", "ModeloC1");
			plano2.removerMarca("MarcaA");
			plano2.removerMarca("MarcaE");			
		}
		catch (Exception e){
			System.out.println("(#156,2) Nao deveria ter vindo para ca!");
		}
		
		String[] marcas13 = {};
		String[] modelos13Result = {};
		
		Assert.assertEquals("(#156,4) Marcas incorretas!", plano2.getMarcas(), marcas13);
		Assert.assertEquals("(#156,6) Modelos incorretos!", plano2.getModelos(), modelos13Result);

		try{
			plano2.removerMarca("MarcaF");
			plano2.removerModeloDaMarca("MarcaF","ModeloF1");
		}
		catch ( Exception e ){
			Assert.assertEquals("(#156,7) Mensagem de erro errada!", e.getMessage(), "A marca solicitada para remocao nao existe!");
		}
		
		try{
			plano2.adicionarMarcaEModelo("MarcaA", "ModeloA1");
			plano2.adicionarMarcaEModelo("MarcaA","ModeloA2");
			plano2.adicionarMarcaEModelo("MarcaB","ModeloB1");
		}
		catch (Exception e){
			System.out.println("(#156,8) Nao deveria ter vindo para ca!");
		}
		
		String[] marcas14 = {"MarcaA","MarcaB"};
		String[] modelos14Result = {"ModeloA1","ModeloA2","ModeloB1"};
		
		Assert.assertEquals("(#156,9) Marcas incorretas!", plano2.getMarcas(), marcas14);
		Assert.assertEquals("(#156,99) Modelos incorretos!", plano2.getModelos(), modelos14Result);

		Assert.assertEquals("(#156,999) 1a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[0], "MarcaA");
		Assert.assertEquals("(#156,9999) 1a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[0], "MarcaB");
		Assert.assertEquals("(#156,99999) 2a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[1], "ModeloA1");
		Assert.assertEquals("(#156,999999) 3a pos. do 1o array incorreto!", plano2.getMarcaXModelos().get(0)[2], "ModeloA2");
		Assert.assertEquals("(#156,9999999) 2a pos. do 2o array incorreto!", plano2.getMarcaXModelos().get(1)[1], "ModeloB1");
		
		String[] modelosX = {"ModeloA1","ModeloA3","ModeloA4","ModeloA5","ModeloA6","ModeloA7","ModeloA8","ModeloA9","ModeloA10","ModeloA11"};
		
		try{
			plano2.adicionarMarcaEModelos("MarcaA", modelosX);
		}
		catch (Exception e){
			Assert.assertEquals("(#157,2) Mensagem de erro errada!", e.getMessage(), "Nao houve espaco para o novo modelo ModeloA10!");
		}
		
		plano2.removerSeguro();
		try{
			plano2.getSeguro();
		}
		catch ( Exception e){
			Assert.assertEquals("(#157,8) Mensagem de erro errada!", e.getMessage(), "Nao contem seguro!");
		}
		try{
			Seguro seguro2 = new Seguro(Cobertura.TOTAL, 100);
			plano2.setSeguro(seguro2);
			Assert.assertEquals("(#158) Seguro errado!", plano2.getSeguro(), seguro2);
		}
		catch ( Exception e ){
			System.out.println("(#159) Nao deveria ter entrado aqui!");
		}
		plano2.removerSeguro();
		try{
			plano2.getSeguro();
		}
		catch ( Exception e){
			Assert.assertEquals("(#160) Mensagem de erro errada!", e.getMessage(), "Nao contem seguro!");
		}
	}
	
	@Test
	public void testaEquals(){
		
		double potencia2 = 15;
		
		String[] marcas1 = {"MarcaA","MarcaB","MarcaC","MarcaD"};
		String[] modelos1 = {"MarcaC","ModeloC1","ModeloC2","MarcaA","ModeloA1","MarcaB","ModeloB1","ModeloB2","ModeloB3","MarcaD","ModeloD1","ModeloD2","ModeloD3","ModeloD4"};
		Acessorio[] acessorios1 = {Acessorio.AB, Acessorio.VE, Acessorio.P2};
		
		String[] marcas2 = {"MarcaA","MarcaB","MarcaD"};
		String[] modelos2 = {"MarcaA","ModeloA1","MarcaB","ModeloB1","ModeloB2","ModeloB3","MarcaD","ModeloD1","ModeloD2","ModeloD3","ModeloD4"};
		Acessorio[] acessorios2 = {Acessorio.AB, Acessorio.VE, Acessorio.P2};
		
		String[] marcas3 = {"MarcaB","MarcaC","MarcaA","MarcaD"};
		String[] modelos3 = {"MarcaC","ModeloC1","ModeloC2","MarcaA","ModeloA1","MarcaD","ModeloD1","ModeloD2","ModeloD3","ModeloD4","MarcaB","ModeloB1","ModeloB2","ModeloB3",};
		Acessorio[] acessorios3 = {Acessorio.VE, Acessorio.AB, Acessorio.P2};
		
		String[] marcas4 = {"MarcaB","MarcaC","MarcaA","MarcaD"};
		String[] modelos4 = {"MarcaC","ModeloC1","ModeloC2","MarcaA","ModeloA1","MarcaD","ModeloD2","ModeloD3","ModeloD4","MarcaB","ModeloB1","ModeloB2","ModeloB3",};
		Acessorio[] acessorios4 = {Acessorio.VE, Acessorio.AB, Acessorio.P2};
		
		String[] marcas5 = {"MarcaB","MarcaC","MarcaA","MarcaD"};
		String[] modelos5 = {"MarcaC","ModeloC1","ModeloC2","MarcaA","ModeloA1","MarcaD","ModeloD1","ModeloD2","ModeloD3","ModeloD4","MarcaB","ModeloB1","ModeloB2","ModeloB3",};
		Acessorio[] acessorios5 = {Acessorio.VE, Acessorio.AB, Acessorio.P2, Acessorio.GPS};
		
		try{
			plano2 = new Plano("00008", marcas1, modelos1, acessorios1,potencia);
			Plano plano3 = new Plano("00009", marcas2, modelos2, acessorios2,potencia);
			Plano plano4 = new Plano("00010", marcas3, modelos3, acessorios3,potencia);
			Plano plano5 = new Plano("00011", marcas4, modelos4, acessorios4,potencia);
			Plano plano6 = new Plano("00012", marcas5, modelos5, acessorios5,potencia);
			Plano plano7 = new Plano("00013", marcas1, modelos1, acessorios1, new Seguro(Cobertura.PARCIAL, 45),potencia);
			Plano plano8 = new Plano("00014", marcas3, modelos3, acessorios3, new Seguro(Cobertura.PARCIAL, 45),potencia);
			Plano plano9 = new Plano("00015", marcas3, modelos3, acessorios3, new Seguro(Cobertura.TOTAL, 65),potencia);

			Plano plano10 = new Plano("00008", marcas1, modelos1, acessorios1,potencia2);
			Plano plano11 = new Plano("00009", marcas2, modelos2, acessorios2,potencia2);
			Plano plano12 = new Plano("00010", marcas3, modelos3, acessorios3,potencia2);
			Plano plano13 = new Plano("00011", marcas4, modelos4, acessorios4,potencia2);
			Plano plano14 = new Plano("00012", marcas5, modelos5, acessorios5,potencia2);
			Plano plano15 = new Plano("00013", marcas1, modelos1, acessorios1, new Seguro(Cobertura.PARCIAL, 45),potencia2);
			Plano plano16 = new Plano("00014", marcas3, modelos3, acessorios3, new Seguro(Cobertura.PARCIAL, 45),potencia2);
			Plano plano17 = new Plano("00015", marcas3, modelos3, acessorios3, new Seguro(Cobertura.TOTAL, 65),potencia2);
			
			Assert.assertFalse(plano2.equals(plano3));
			Assert.assertTrue(plano4.equals(plano2));
			Assert.assertTrue(plano2.equals(plano4));
			Assert.assertFalse(plano2.equals(plano5));
			Assert.assertFalse(plano2.equals(plano6));
			Assert.assertFalse(plano2.equals(plano7));
			Assert.assertFalse(plano4.equals(plano7));
			Assert.assertTrue(plano7.equals(plano8));
			Assert.assertFalse(plano7.equals(plano9));
			
			Assert.assertFalse(plano10.equals(plano11));
			Assert.assertTrue(plano12.equals(plano10));
			Assert.assertTrue(plano10.equals(plano12));
			Assert.assertFalse(plano10.equals(plano13));
			Assert.assertFalse(plano10.equals(plano14));
			Assert.assertFalse(plano10.equals(plano15));
			Assert.assertFalse(plano12.equals(plano15));
			Assert.assertTrue(plano15.equals(plano16));
			Assert.assertFalse(plano15.equals(plano17));
			
			Assert.assertFalse(plano2.equals(plano10));
			Assert.assertFalse(plano3.equals(plano11));
			Assert.assertFalse(plano4.equals(plano12));
			Assert.assertFalse(plano5.equals(plano13));
			Assert.assertFalse(plano6.equals(plano14));
			Assert.assertFalse(plano7.equals(plano15));
			Assert.assertFalse(plano8.equals(plano16));
			Assert.assertFalse(plano9.equals(plano17));
		}
		catch (Exception e){
			System.out.println("(#161) Nao deveria entrar aqui, o erro foi: "+e.getMessage());
		}
	}
}